﻿using System;
using System.Collections.Generic;
using System.Text;

using Sinacor.Servico.Bovespa.Ordens;
using Sinacor.Servico.Bovespa.Calendario;
using Sinacor.Servico.Bovespa.Cliente;
using Sinacor.Servico.Bovespa.ResumoFinanceiro;
using Sinacor.Servico.Bovespa.Operador;
using Sinacor.Servico.Bovespa.Titulo;

using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using Sinacor.Infra.Service.Common;

namespace Sinacor.Servico.Bovespa.Ordens.BusinessLogic
{
    public class OrdemMegaBolsa : BaseBusinessLogic
    {
        #region Constantes de Erro
        private const int ERRO_ORDEMMEGABOLSA_CONSULTASEMRESULTADO = 103023;
        private const int ERRO_ORDEMMEGABOLSA_DATAPREGAOCONSULTAINVALIDA = 103024;
        private const int ERRO_ORDEMMEGABOLSA_OPERADORCONSULTAINVALIDO = 103025;
        private const int ERRO_ORDEMMEGABOLSA_ORDEMINVALIDAPARAALTERACAO = 103026;
        private const int ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARORDEM = 103027;
        private const int ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARORDEMDATAANTERIOR = 103028; //criado erro analogo (com novo numero 103197) na classe Ordem - esertorio - 200804281455 - ref issue ID0003686
        private const int ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARPERCENTUALREDACR = 103029;
        private const int ERRO_ORDEMMEGABOLSA_NATUREZAOPERACAONULO = 103030;
        private const int ERRO_ORDEMMEGABOLSA_TIPOMERCADONULO = 103031;
        private const int ERRO_ORDEMMEGABOLSA_CARTEIRAINVALIDA = 103032;
        private const int ERRO_ORDEMMEGABOLSA_CARTEIRANULO = 103033;
        private const int ERRO_ORDEMMEGABOLSA_TIPOLIQUIDACAOINVALIDO = 103034;
        private const int ERRO_ORDEMMEGABOLSA_TIPOLIQUIDACAOINVALIDOPARATIPOMERCADO = 103035;
        private const int ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO = 103036;
        private const int ERRO_ORDEMMEGABOLSA_CODIGOCLIENTEINVALIDO = 103037;
        private const int ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARORDEMSEMCLIENTE = 103038;
        private const int ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARCLIENTEDAORDEM = 103039;
        private const int ERRO_ORDEMMEGABOLSA_ORDEMCASADAFORAPRAZOALTERACAO = 103040;
        //private const int ERRO_ORDEMMEGABOLSA_ORDEMINVALIDADATAPREGAOPREBOLETO = 103041; //excluida - constante migrada para classe Ordem - esertorio - 200804281455 - ref issue ID0003686
        //private const int ERRO_ORDEMMEGABOLSA_ORDEMSEMMARCACASAMENTO = 103042; //excluida - constante migrada para classe Ordem - esertorio - 200804281455 - ref issue ID0003686
        //private const int ERRO_ORDEMMEGABOLSA_DATAPREGAOPREBOLETOINVALIDA = 103043; //excluida - constante migrada para classe Ordem - esertorio - 200804281455 - ref issue ID0003686
        private const int ERRO_ORDEMMEGABOLSA_DATAORDEMNULO = 103044;
        private const int ERRO_ORDEMMEGABOLSA_NUMEROORDEMNULO = 103045;
        private const int ERRO_ORDEMMEGABOLSA_FALHARECEPCAO = 103046;
        private const int ERRO_ORDEMMEGABOLSA_FALHAALTERACAO = 103047;
        private const int ERRO_ORDEMMEGABOLSA_DATAPREGAONULO = 103049;
        private const int ERRO_ORDEMMEGABOLSA_VALORESALTERACAONULOS = 103050;
        private const int ERRO_ORDEMMEGABOLSA_NUMEROSUBSEQORDEMNULO = 103051;
        private const int ERRO_ORDEMMEGABOLSA_CLIENTEBLOQUEADO = 103053;
        private const int ERRO_ORDEMMEGABOLSA_TIPOLIQUIDACAONULO = 103059;
        private const int ERRO_ORDEMMEGABOLSA_PERCENTUALREDACRNULO = 103060;
        //private const int ERRO_ORDEMMEGABOLSA_DATAMOVIMENTOMAIORDATAVALIDADE = 103071; //excluida - constante migrada para classe Ordem - esertorio - 200804281455 - ref issue ID0003686
        private const int ERRO_ORDEMMEGABOLSA_CLIENTEDESATIVADO = 103198; //20080502 15:08 - RValadao - Inclusão de tratamento de exceção quando cliente está cancelado.
        private const int ERRO_NEGOCIO_CONTROLE_ORDENS_FECHADO = 103205;
        private const int ERRO_PERCENTUALDESCONTOAPLICADOINVALIDO = 104014;//Percentual de desconto aplicado é inválido.
        #endregion

        private ValidationException validationException = new ValidationException();

        private bool isOrdemDescasada = false;
        private bool isApelidoAlterado = false;
        private bool isTipoLiquidacaoAlterado = false;
        private bool isCarteiraAlterada = false;
        private bool isPercentualCorretagemAlterado = false;

        //incluido - Eduardo Sertorio - 20080102
        private enum ValidacaoParcial 
        { 
            Nao,
            Carteira,
            TipoLiquidacao,
            PercentualReducaoAcrescimo
        }

        #region Region_ConsultarOrdemMegaBolsa
        /// <summary>
        /// Metodo responsavel por consultar ordens da mega bolsa
        /// Data: 26/11/2007
        /// Autor: Eduardo Sertorio
        /// Obs: Criacao do metodo
        /// 
        /// Data : 26/11/2007
        /// Autor: Eduardo Sertorio
        /// Obs. : Revisao para filtrar NumeroOrdemSubSequencia
        /// </summary>
        /// <param name="request"></param>
        /// <param name="dataPregao"></param>
        /// <returns></returns>
        public List<BusinessEntity.OrdemMegaBolsa> ConsultarOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa request)
        {
            ValidarConsultarOrdemMegaBolsa(request);

            if (validationException.ValidationErrors != null 
                && validationException.ValidationErrors.Count != 0)
            {
                throw validationException;
            }

            List<BusinessEntity.OrdemMegaBolsa> response = (new ResourceAccess.OrdemMegaBolsa()).ConsultarOrdemMegaBolsa(request);

            response = ConsultarApelidoNomeCliente(response);

            if ((response != null) && (response.Count.Equals(0)))
            {
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_CONSULTASEMRESULTADO); //"Consulta de Ordem da Mega Bolsa sem resultado."
            }
            else
            {
                return response;
            }
        }

        /// <summary>
        /// Metodo responsavel por validar os parametros da consulta de ordens da mega bolsa
        /// Data: 26/11/2007
        /// Autor: Eduardo Sertorio
        /// Obs: Criacao do metodo
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private void ValidarConsultarOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa request)
        {
            ValidarDataPregao(request.DataOrdem);
            ValidarNumeroOrdem(request.NumeroOrdem);
            ValidarApelidoClienteConsulta(request);
            ValidarTitulo(request.Titulo, request.DataOrdem);
            ValidarOperador(request.Operador);
            return;
        }

        private List<BusinessEntity.OrdemMegaBolsa> ConsultarApelidoNomeCliente(List<BusinessEntity.OrdemMegaBolsa> OrdemMegaBolsaCollection)
        {
            Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente raCliente = new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente();
            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente beClienteResponse = null;

            foreach (BusinessEntity.OrdemMegaBolsa item in OrdemMegaBolsaCollection)
            {
                beClienteResponse = null;
                beClienteResponse = raCliente.ConsultarPorCodigo(item.Cliente.Codigo.Value);
                if (beClienteResponse != null)
                {
                    //item.Cliente.Apelido = beClienteResponse.Apelido; //alterado - Eduardo Sertorio - 20071213
                    item.Cliente = beClienteResponse;
                }
                else
                {
                    item.Cliente.Apelido = "Cliente não encontrado.";
                }
            }

            return OrdemMegaBolsaCollection;
        }

        private void ValidarDataPregao(DateTime? dataPregao)
        {
            if (dataPregao.HasValue)
                if((new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario()).ValidarDataCalendario(dataPregao.Value) == false)
                {
                    validationException.AddError(ERRO_ORDEMMEGABOLSA_DATAPREGAOCONSULTAINVALIDA); //"Data do pregão inválida para consulta de ordens da mega bolsa."
                }
        }

        private void ValidarNumeroOrdem(Int32? numeroOrdem)
        {
            //VALIDACAO DESNECESSARIA - Ordem faz parte do filtro da consulta - Eduardo Sertorio - 20071213
        }

        private void ValidarTitulo(String titulo, DateTime? dataPregao)
        {
            //desnecessario validar titulo/papel conforme email do Nemir em 18/12/2007 12:09
        }

        private void ValidarOperador(Int32? _operador)
        {
            if (!_operador.HasValue)
                return;

            Sinacor.Servico.Bovespa.Operador.ResourceAccess.Operador raOperador = new Sinacor.Servico.Bovespa.Operador.ResourceAccess.Operador();
            Sinacor.Servico.Bovespa.Operador.BusinessEntity.Operador beOperador = new Sinacor.Servico.Bovespa.Operador.BusinessEntity.Operador();
            beOperador.CodigoOperador = _operador.Value;
            if (raOperador.ValidarPorCodigo(beOperador) == false)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_OPERADORCONSULTAINVALIDO); //"Operador inválido para consulta de ordens da mega bolsa."
            }
        }

        #endregion

        #region Region_AlterarOrdemMegaBolsa

        /// <summary>
        /// Metodo responsavel por validar os parametros da consulta de ordens da mega bolsa
        /// Data: 06/12/2007
        /// Autor: Eduardo Sertorio
        /// Obs: Criacao do metodo
        /// 
        /// Data: 26/12/2007
        /// Autor: Eduardo Sertorio
        /// Obs: Alteracao para retornar BusinessEntity.OrdemMegaBolsa ordemAlterada com mensagemVerificacaoSaldo e dados do BloqueioCliente
        /// </summary>
        /// <param name="ordemAlterada"></param>
        /// <param name="dataPregao"></param>
        /// <returns>BusinessEntity.OrdemMegaBolsa</returns>
        public BusinessEntity.OrdemMegaBolsa AlterarOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa ordemAlterada, DateTime? dataPregao)
        {
            ordemAlterada.IsValidacaoOk = false;
            ordemAlterada.IsAlteracaoOk = false;

            //Obter ordem atual para validacoes
            BusinessEntity.OrdemMegaBolsa ordemAtual = null;


            //Validar ordem alterada
            ValidarAlterarOrdemMegaBolsa(ordemAlterada, ref ordemAtual, ValidacaoParcial.Nao);

            //20080425 12:25 - RValadao
            //A verificação é feita dentro do método ValidarAlterarOrdemMegaBolsa
            //ordemAlterada.IsValidacaoOk = true;

            //se algum campo foi alterado
            if ((isApelidoAlterado || isCarteiraAlterada || isPercentualCorretagemAlterado || isTipoLiquidacaoAlterado)
                && ordemAlterada.IsValidacaoOk)
            {
                //Alterar a ordem
                AlterarOrdem(ordemAlterada);

                //Validar saldo e obter mensagem de aviso, se houver
                ValidarSaldoNegociavel(ordemAtual, ordemAlterada);

                //Casar a ordem alterada
                CasarOrdemAlterada();

                //Recalcular valores dos clientes envolvidos
                DispararCalculoFinanceiroPacote(ordemAlterada, ordemAtual, dataPregao);

                ordemAlterada.IsAlteracaoOk = true;
            }

            return ordemAlterada;
        }

        private void ValidarAlterarOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa ordemAlterada, ref BusinessEntity.OrdemMegaBolsa ordemAtual, ValidacaoParcial _validacaoParcial)
        {
            //20080512 17:52 - RValadao
            //Valida o estado do sistema, issue 4623
            ValidarEstadoSistema();

            if (!ordemAlterada.DataOrdem.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_DATAORDEMNULO); //"Data da ordem não podem ser nulo."
            }

            if (!ordemAlterada.NumeroOrdem.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_NUMEROORDEMNULO); //"Numero da ordem não podem ser nulo."
            }

            if (!ordemAlterada.NumeroOrdemSubSequencia.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_NUMEROSUBSEQORDEMNULO); //"Numero sub-sequencia da ordem não podem ser nulo."
            }

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                if ( 
                    ((ordemAlterada.Cliente==null) || String.IsNullOrEmpty(ordemAlterada.Cliente.Apelido))
                    && ordemAlterada.TipoLiquidacao.ToString() != null
                    && !ordemAlterada.Carteira.HasValue
                    && !ordemAlterada.PercentualReducaoAcrescimo.HasValue
                    )
                {
                    validationException.AddError(ERRO_ORDEMMEGABOLSA_VALORESALTERACAONULOS); //"Nenhum campo da alteração foi informado."
                }

            if ((validationException.ValidationErrors != null) && (validationException.ValidationErrors.Count != 0))
            {
                ordemAlterada.IsAlteracaoOk = false;
                throw validationException;
            }

            //obter dados da ordem atual
            ordemAtual = ObterOrdemAtual(ordemAlterada);

            //20080512 19:28 - RValadao
            //Validação do percentual reduacao acrescimo.
            if (ordemAlterada.PercentualReducaoAcrescimo != ordemAtual.PercentualReducaoAcrescimo)
                ValidarPercentualReducaoAcrescimoOrdemMegaBolsa(ordemAlterada);


            if (_validacaoParcial.Equals(ValidacaoParcial.Nao) 
                || _validacaoParcial.Equals(ValidacaoParcial.PercentualReducaoAcrescimo)
                || _validacaoParcial.Equals(ValidacaoParcial.Carteira)
                )
            {
                //obter apelido do cliente da ordem atual
                Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente beCliente = 
                    (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPorCodigo(ordemAtual.Cliente.Codigo.Value);
                if (beCliente != null)
                    ordemAtual.Cliente = beCliente;
            }

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
            {
                //20080512 19:16 - RValadao
                //Funcao não utilizada em Ordens Mega Bolsa
                //if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("AORD"))
                //{
                //    throw new BusinessException(ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARORDEM); //"Usuário sem permissão para alterar ordem."
                //}

                //  -- Se data da ordem ( TORMOVD.DT_DATORD ) < data do sistema ( TORDATMOV.DT_DATMOV )
                if (ordemAlterada.DataOrdem < (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento())
                {
                    //se nao existir permissão para a função D1SIM
                    if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("D1SIM"))
                    {
                        //msg erro validacao
                        throw new BusinessException(ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARORDEMDATAANTERIOR); //"Usuário sem permissão para alterar ordem com data anterior a data do sistema."
                    }
                }
            }

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                ValidarApelidoClienteAlteracao(ordemAlterada, ordemAtual);

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao) || _validacaoParcial.Equals(ValidacaoParcial.TipoLiquidacao))
                ValidarTipoLiquidacao(ordemAlterada, ordemAtual);

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao) || _validacaoParcial.Equals(ValidacaoParcial.Carteira))
                ValidarCarteira(ordemAlterada, ordemAtual);

            //20080513 00:08 - RValadao
            //Metodo comentado pois já é utilizado dentro de outro método.
            //if (_validacaoParcial.Equals(ValidacaoParcial.Nao) || _validacaoParcial.Equals(ValidacaoParcial.PercentualReducaoAcrescimo))
            //    ValidarPercentualCorretagem(ordemAlterada, ordemAtual);

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                ValidarDataValidade(ordemAlterada, ordemAtual);

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
            {
                ValidarBloqueio(ordemAlterada, ordemAtual);
                if (ordemAlterada.Cliente.Bloqueio.isBloqueado &&
                    (ordemAlterada.Cliente != ordemAtual.Cliente))
                    return;
            }

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                ValidarRecepcao(ordemAlterada, ordemAtual);

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                ValidarClienteBroker(ordemAlterada, ordemAtual);

            if ((validationException.ValidationErrors != null) && (validationException.ValidationErrors.Count != 0))
            {
                throw validationException;
            }

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                AtualizarAlteracaoCliente(ordemAlterada, ordemAtual);

            if (_validacaoParcial.Equals(ValidacaoParcial.Nao))
                AtualizarAlteracaoPercentualReducaoAcrescimo(ordemAlterada, ordemAtual);


            //20080425 12:29 - RValadao
            //Passou por toda a validação então marca como ok
            ordemAlterada.IsValidacaoOk = true;
        }

        private BusinessEntity.OrdemMegaBolsa ObterOrdemAtual(BusinessEntity.OrdemMegaBolsa ordemAlterada)
        {
            ResourceAccess.OrdemMegaBolsa raOrdemMegaBolsa = new ResourceAccess.OrdemMegaBolsa();

            List<BusinessEntity.OrdemMegaBolsa> listaordem = raOrdemMegaBolsa.ConsultarPorChave(ordemAlterada);

            if ((listaordem == null) || (listaordem.Count != 1))
            {
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_ORDEMINVALIDAPARAALTERACAO); //"Ordem mega bolsa informada para alteração não foi encontrada."
            }
            else
            {
                return listaordem[0];
            }
        }

        private void AlterarOrdem(BusinessEntity.OrdemMegaBolsa ordemAlterada)
        {
            if (!(new ResourceAccess.OrdemMegaBolsa()).Alterar(ordemAlterada, isOrdemDescasada).Equals(1))
            {
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_FALHAALTERACAO); //"Erro ao atualizar ordem mega bolsa."
            }
        }

        private void ValidarPercentualCorretagem(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //se percentual foi informado
            if (ordemAlterada.PercentualReducaoAcrescimo.HasValue)
            {
                //se Percentual corretagem nao foi alterado
                if (ordemAtual!=null && ordemAlterada.PercentualReducaoAcrescimo.Equals(ordemAtual.PercentualReducaoAcrescimo))
                {
                    //Abandonar validacao.
                    return;
                }
                else                
                {
                    //senao
                    //segue validacao
                    isPercentualCorretagemAlterado = true;
                }
            }
            else
            {
                //senao
                //valor original sera assumido
                if(ordemAtual!=null)
                    ordemAlterada.PercentualReducaoAcrescimo = ordemAtual.PercentualReducaoAcrescimo.Value;
                //validacao sera abandonada
                return;
            }

            // Na inclusão a informação é solicitada ao Cadastro de Clientes para ser gravada na ordem. 
            // As alterações devem seguir a RN0084-ORD.
            // A informação só pode ser alterada se o usuário possuir no seu perfil a atribuição de alteração deste atributo. 
            // A informação válida para este atributo depende do tipo de cobrança de corretagem do cliente:
            // Tabela de Corretagem: Este percentual reflete acréscimo ou redução sobre o valor bruto de corretagem apurado. 
            // Para este caso o percentual pode ser qualquer valor igual ou acima de -100 ( cem negativo ).
            // Custo Total: Este percentual é utilizado para o cálculo efetivo da corretagem. 
            // Para este caso o valor deve ser maior ou igual a zero.

            if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("ARED"))
            {
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARPERCENTUALREDACR); //"Sem permissão para alterar percentual de redução ou acréscimo."
            }

            
            //20080512 19:02 - RValadao 
            //Verificação do percentual do custo total do volume
            decimal percentualCustoTotalVolume;
            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente cliente = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente();

            cliente.Codigo = ordemAlterada.Cliente.Codigo.Value;
            percentualCustoTotalVolume = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPercentualCustoTotalVolume(cliente);

            if (percentualCustoTotalVolume == 0)
            {
                if (ordemAlterada.PercentualReducaoAcrescimo < -100)
                    throw new BusinessException(ERRO_PERCENTUALDESCONTOAPLICADOINVALIDO);
            }
            else if (percentualCustoTotalVolume >= 0)
            {
                if (ordemAlterada.PercentualReducaoAcrescimo < 0)
                    throw new BusinessException(ERRO_PERCENTUALDESCONTOAPLICADOINVALIDO);
            }

        }

        private void ValidarCarteira(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //se carteira foi informada
            if (ordemAlterada.Carteira.HasValue)
            {
                //se carteira nao foi alterada
                if (ordemAlterada.Carteira.Value.Equals(ordemAtual.Carteira.Value))
                {
                    //abandonar validacao
                    return;
                }
                else 
                {
                    //senao
                    //segue validacao
                    isCarteiraAlterada = true;
                }
            }

            if (!ordemAtual.NaturezaOperacao.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_NATUREZAOPERACAONULO); //"Natureza de Operação não pode ser nulo."
            }

            if (!ordemAtual.TipoMercado.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_TIPOMERCADONULO); //"Tipo de Mercado não pode ser nulo."
            }

            if (validationException.ValidationErrors != null && validationException.ValidationErrors.Count != 0)
            {
                throw validationException;
            }

            Ordens.ResourceAccess.Carteira raCarteira = new Ordens.ResourceAccess.Carteira();
            int carteira_obtida = -1; //o valor zero é uma carteira valida.

            // Se carteira nao for informada 
            if (!ordemAlterada.Carteira.HasValue)
            {
                //-- Carteira (Carliq )
                // A Carteira deve estar cadastrada e ter relacionamento com o Mercado e Natureza de Operação informados na Ordem. 
                // buscar primeira ocorrência do retorno da query abaixo:
                carteira_obtida = raCarteira.ConsultarPorCodigo(null, ordemAtual.TipoMercado.Value, ordemAtual.NaturezaOperacao.Value, ordemAtual.Bolsa);

                // Se a consulta nao obter carteira valida
                if (carteira_obtida.Equals(-1))
                {
                    // obrigar a informação da carteira
                    validationException.AddError(ERRO_ORDEMMEGABOLSA_CARTEIRANULO); //"Carteira deve ser informada."
                }
                else
                {
                    // Senao, assumir carteira obtida em cadastro.            
                    ordemAlterada.Carteira = carteira_obtida;
                }
            }
            else
            {
                //senao, validar se esta relacionada com mercado, natureza de operacao e bolsa
                if (!raCarteira.ValidarCarteira(
                        ordemAlterada.Carteira, 
                        ordemAtual.TipoMercado.Value, 
                        ordemAtual.NaturezaOperacao.Value, 
                        ordemAtual.Bolsa))
                {
                    throw new BusinessException(ERRO_ORDEMMEGABOLSA_CARTEIRAINVALIDA); //"Carteira informada não está relacionada com mercado, natureza de operacao e bolsa."
                }
            }
        }

        private void ValidarTipoLiquidacao(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //se Tipo Liquidacao foi informada
            if (ordemAlterada.TipoLiquidacao != null)
            {
                //se Tipo Liquidacao nao foi altedada
                if (ordemAlterada.TipoLiquidacao.Equals(ordemAtual.TipoLiquidacao))
                {
                    //abandonar validacao.
                    return;
                }
                else
                {
                    //senao
                    //segue validacao
                    isTipoLiquidacaoAlterado = true;
                }
            }
            else
            {
                //senao
                //abandonar validacao.
                return; 
            }

            //   -- Aceita 'C' ou nulo
            if (!ordemAlterada.TipoLiquidacao.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Custodiante) //corrigido - eduardo sertorio - 200802271130
                &&
                !ordemAlterada.TipoLiquidacao.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal)//corrigido - eduardo sertorio - 200802271130
                ) 
            {
                // A Informação é obrigatória e o cliente informado deve respeitar a RN0008-ORD
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_TIPOLIQUIDACAOINVALIDO); //"Tipo de liquidação inválido."
            }

            if (ordemAlterada.TipoLiquidacao.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Custodiante))
            {
                //20080425 16:06 - RValadao
                //O atributo 'C' só é aceito somente para os mercados VIS, FRA, EST, EOC, EOV e LEI
                if (!(ordemAtual.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista) //VIS
                    || ordemAtual.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario) //FRA
                    || ordemAtual.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado) //EST
                    || ordemAtual.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra) //EOC
                    || ordemAtual.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda) //EOV
                    || ordemAtual.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Leilao) //LEI
                    ))
                {
                    throw new BusinessException(ERRO_ORDEMMEGABOLSA_TIPOLIQUIDACAOINVALIDOPARATIPOMERCADO); //"Tipo de liquidação inválido para o tipo de mercado utilizado."
                }
            }
        }

        private void ValidarApelidoClienteAlteracao(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //se cliente nao foi informado
            if (ordemAlterada.Cliente == null)
            {
                //assume cliente atual
                ordemAlterada.Cliente = ordemAtual.Cliente;
                //abandonar validacao
                return; 
            }
            else
            {
                //se apelido nao foi informado
                if (String.IsNullOrEmpty(ordemAlterada.Cliente.Apelido))
                {
                    //assume cliente atual
                    ordemAlterada.Cliente = ordemAtual.Cliente;
                    //abandonar validacao
                    return;
                }
                else 
                {
                    //se apelido nao foi alterado
                    if (ordemAlterada.Cliente.Apelido.Equals(ordemAtual.Cliente.Apelido))
                    {
                        //assume cliente atual
                        ordemAlterada.Cliente = ordemAtual.Cliente;
                        //abandonar validacao
                        return;
                    }
                    else
                    {
                        //senao
                        //segue validacao
                        isApelidoAlterado = true;
                    }
                }
            }

            Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente raCliente = new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente();
            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente beCliente = null;

            beCliente = raCliente.ConsultarPorApelido(ordemAlterada.Cliente.Apelido);

            if ((beCliente == null) || beCliente.Codigo.Value.Equals(0))
            {
                // A Informação é obrigatória e o cliente informado deve respeitar a RN0008-ORD
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO); //"Apelido do cliente inválido."
            }
            else
            {
                //ordem alterada assume cliente pelo novo apelido
                ordemAlterada.Cliente = beCliente;
            }

            //-- Cliente / Apelido ( na tela )
            if (!ordemAlterada.Cliente.Codigo.Value.Equals(ordemAtual.Cliente.Codigo))
            {
                if (ordemAlterada.Cliente.Codigo.Value.Equals(0))
                {
                    throw new BusinessException(ERRO_ORDEMMEGABOLSA_CODIGOCLIENTEINVALIDO); //"Nao é permitido gravar ordem com codigo de cliente zero."
                }

                //   -- Para alterar código de cliente 0 para qualquer outro deve existir permissão ( função 'ACLI0' )
                if (ordemAtual.Cliente.Codigo.Value.Equals(0))
                {
                    if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("ACLI0"))
                    {
                        throw new BusinessException(ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARORDEMSEMCLIENTE); //"Usuario sem permissao para alterar ordem sem Sinacor.Servico.Bovespa.Cliente."
                    }
                }
                else
                {
                    //   -- Para alterar código de cliente de não 0 para qualquer outro deve existir permissão ( função 'ACLI' )
                    if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("ACLI"))
                    {
                        throw new BusinessException(ERRO_ORDEMMEGABOLSA_SEMPERMISSAOALTERARCLIENTEDAORDEM); //"Usuario sem permissao para alterar cliente da ordem."
                    }
                }
            }
        }

        private void ValidarApelidoClienteConsulta(BusinessEntity.OrdemMegaBolsa ordemMegaBolsa)
        {
            if (ordemMegaBolsa.Cliente != null)
            {
                if (String.IsNullOrEmpty(ordemMegaBolsa.Cliente.Apelido)==false)
                {
                    //Validar apelido
                    Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente raCliente = new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente();
                    Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente beCliente = null;
                    beCliente = raCliente.ConsultarPorApelido(ordemMegaBolsa.Cliente.Apelido);
                    if (beCliente == null)
                        throw new BusinessException(ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO); //"Apelido do Cliente inválido."
                    else
                        ordemMegaBolsa.Cliente = beCliente;
                }
            }
        }

        private void ValidarDataValidade(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //dtCal
            DateTime? menorDataMovimentoCalendario = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario()).RecuperarMenorDataMovimentoCalendarioPraca(ordemAtual.Bolsa);

            //dtMov
            DateTime? menorDataNegocioComitente = (new ResumoFinanceiro.ResourceAccess.Comitente()).RecuperarMenorDataNegocioComitente(
                ordemAtual.Bolsa, 
                ordemAtual.DataOrdem.Value, 
                ordemAtual.NumeroOrdem.Value, 
                ordemAtual.NumeroOrdemSubSequencia.Value);

            if (!menorDataNegocioComitente.HasValue)
            {
                return; //abandonar a validacao da data de validade se nao obter menor data de negocio da ordem na tabela de comitente.(nemir - 20071219)
            }

            //incluido - eduardo - 20080119
            if (!menorDataMovimentoCalendario.HasValue)
            {
                return; //abandonar a validacao da data de validade se nao obter data.(nemir - 20071219)
            }

            //Se dtCal > dtMov
            if (menorDataMovimentoCalendario.Value > menorDataNegocioComitente.Value)
            {
                //Mensagem: Ordem com validade já casada fora do prazo para alteração de suas características e para exclusão.
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_ORDEMCASADAFORAPRAZOALTERACAO); //"Ordem já casada com validade fora do prazo para alteração de suas características e para exclusão."
            }
        }

        private void ValidarBloqueio(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //Não pode possuir bloqueio se ordem ativa ( TORMOVD.IN_SITUAC <> 'D' ):
            if (ordemAtual.Situacao.Equals("D")) //desativada
                return; //ordem nao esta ativa. abandonar validacao de bloqueio.

            //boolean pOr_Bloqueio.fOr_Exis_Bloq( :nCodCli, :sTipoMerc, :sNatOpe, :sCodNeg, :sDataPreg, out :srTipoBloq, out :srDescBloq )
            //Retorna TRUE se existir bloqueio e FALSE se não existir
            //onde: 
            //nCodCli   = TORMOVD.CD_CLIENTE
            //sTipoMerc = Frmordmega.tblTorordmega.colMercado
            //sNatOpe   = Frmordmega.tblTorordmega.colNatope
            //sCodNeg   = Frmordmega.tblTorordmega.colNegsp
            //sDataPreg:
            //Se TORMOVD.DT_VALORD < TORDATMOV.DT_DATMOV
            //  sDataPreg = TORMOVD.DT_VALORD
            //caso contrário
            //  sDataPreg = TORDATMOV.DT_DATMOV
            //srTipoBloq: Retorna o tipo do bloqueio
            //(C)liente
            //(A)ssessor
            //(T)ipo de cliente
            //(G)rupo de afinidade
            //(M)ercado
            //(P)apel
            //srDescBloq: Retorna a descrição do bloqueio

            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente beBloqueioClienteRequest = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente();
            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente beBloqueioClienteResponse = null;

            //dbClienteBloqueio.AddInParameter(dbCommand, "NCODCLI", DbType.Int32, request.CodCliente);
            beBloqueioClienteRequest.CodigoCliente = ordemAlterada.Cliente.Codigo.Value;

            //dbClienteBloqueio.AddInParameter(dbCommand, "STIPOMERC", DbType.String, request.Mercado);
            beBloqueioClienteRequest.Mercado = (Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado) ordemAtual.TipoMercado;

            //dbClienteBloqueio.AddInParameter(dbCommand, "SNATOPE", DbType.String, request.NaturezaOperacao);
            beBloqueioClienteRequest.NaturezaOperacao = (Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoNaturezaOperacao)ordemAtual.NaturezaOperacao;
            
            //dbClienteBloqueio.AddInParameter(dbCommand, "SCODNEG", DbType.String, request.CodNegocio);
            beBloqueioClienteRequest.CodigoNegocio = ordemAtual.Titulo;

            //dbClienteBloqueio.AddInParameter(dbCommand, "SDATAPREG", DbType.Date, request.DataPregao);
            //Se TORMOVD.DT_VALORD < TORDATMOV.DT_DATMOV
            DateTime dataMovimento = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();
            if (ordemAtual.DataValidade < dataMovimento)
            {
                //  sDataPreg = TORMOVD.DT_VALORD
                beBloqueioClienteRequest.DataPregao = ordemAtual.DataValidade;
            }
            //caso contrário
            else
            {
                //sDataPreg = TORDATMOV.DT_DATMOV
                beBloqueioClienteRequest.DataPregao = dataMovimento;
            }

            beBloqueioClienteResponse = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).VerificarBloqueioCliente(beBloqueioClienteRequest);

            ordemAlterada.Cliente.Bloqueio = beBloqueioClienteResponse;
            
            //20080427 16:02 - RValadao
            //Verifica se o cliente está bloqueado, resolução bug 3693
            if (ordemAlterada.Cliente != ordemAtual.Cliente)
            {
                if (!ordemAlterada.Cliente.Bloqueio.isBloqueado)
                {
                    //20080427 16:16 - RValadao
                    //Valida se o cliente está bloqueado se não voltar a descrição do bloqueio na 
                    //verificação anterior.
                    if (!new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente().ValidarClienteDesativado(ordemAlterada.Cliente.Apelido))
                    {
                        throw new BusinessException(ERRO_ORDEMMEGABOLSA_CLIENTEDESATIVADO);
                    }
                }
                else
                    ordemAlterada.IsValidacaoOk = false;
            }

        }

        private void ValidarRecepcao(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //Não pode possuir falha de recepção
            //Se nQtd > 0
            //existe falha

            if ((new ResourceAccess.OrdemMegaBolsa()).ValidarRecepcao(ordemAlterada) > 0)
            {
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_FALHARECEPCAO); //"Não é permitido alterar ordem com falha de recepção."
            }
        }

        private void ValidarClienteBroker(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            if (ordemAlterada.Cliente == null)
                return; //cliente nao alteado. abandonar validacao
            else
                if (!ordemAlterada.Cliente.Codigo.HasValue)
                    return; //cliente nao alteado. abandonar validacao

            //Se Cliente for Broker
            if ((new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ValidarClienteBroker(ordemAlterada.Cliente.Codigo.Value))
            {
                //Ordem deve ser discricionária: 
                //TORMOVD.TP_ORDEM deve possuir o número 4 na unidade ou na dezena
                if (!ordemAtual.TipoOrdem.ToString().Contains("4"))
                {
                    //se não possuir, assumir automaticamente
                    ordemAlterada.TipoOrdem = 4;
                }
            }
            //Senão
            else
            {
                //Ordem não pode ser discricionária: 
                //TORMOVD.TP_ORDEM não pode possuir o número 4 na unidade ou na dezena
                if (ordemAtual.TipoOrdem.ToString().Contains("4") == true)
                {
                    //se possuir, tirar automaticamente
                    String tipoOrdemString = ordemAtual.TipoOrdem.ToString().Replace("4", "");
                    if (String.IsNullOrEmpty(tipoOrdemString))
                        ordemAlterada.TipoOrdem = 0;
                    else
                        ordemAlterada.TipoOrdem = Convert.ToInt32(tipoOrdemString);
                }
            }
        }

        private void AtualizarAlteracaoCliente(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            //Se alterou cliente ou tipo de liquidação ou carteira disparar o pacote:
            //PR_SINCRO.ATUA_ALT_CLI( 
            //<Data da Ordem>,
            //<Numero da Ordem>,
            //<Subsequencia da Ordem>,
            //<Codigo do cliente anterior a alteração>,
            //<Codigo da bolsa anterior a alteração>,
            //'N' )

            if (!ordemAlterada.Cliente.Codigo.Value.Equals(ordemAtual.Cliente.Codigo)
                || !ordemAlterada.TipoLiquidacao.Equals(ordemAtual.TipoLiquidacao)
                || !ordemAlterada.Carteira.Value.Equals(ordemAtual.Carteira))
            {
                (new ResourceAccess.OrdemMegaBolsa()).AtualizarAlteracaoCliente(
                    ordemAlterada.DataOrdem.Value, 
                    ordemAlterada.NumeroOrdem.Value, 
                    ordemAlterada.NumeroOrdemSubSequencia.Value, 
                    ordemAtual.Cliente.Codigo.Value, 
                    ordemAtual.Bolsa, 
                    "N");

                //devera zerar quantidade na alteracao da ordem
                isOrdemDescasada = true;
            }

        }

        private void AtualizarAlteracaoPercentualReducaoAcrescimo(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual)
        {
            if (!ordemAlterada.PercentualReducaoAcrescimo.HasValue)
                return; //nao foi informado percentual para alteracao. abandonar validacao.

            if (!ordemAlterada.PercentualReducaoAcrescimo.Value.Equals(ordemAtual.PercentualReducaoAcrescimo.Value))
            {
                (new ResourceAccess.OrdemMegaBolsa()).AtualizarAlteracaoPercentualReducaoAcrescimo(
                    ordemAlterada.DataOrdem.Value,
                    ordemAlterada.NumeroOrdem.Value,
                    ordemAlterada.NumeroOrdemSubSequencia.Value, 
                    ordemAtual.Cliente.Codigo.Value, 
                    ordemAtual.Bolsa,
                    ordemAlterada.PercentualReducaoAcrescimo.Value);

                //devera zerar quantidade na alteracao da ordem
                isOrdemDescasada = true;
            }
        }

        private void ValidarSaldoNegociavel(BusinessEntity.OrdemMegaBolsa ordemAtual,BusinessEntity.OrdemMegaBolsa ordemAlterada)
        {
            //   Avisar o usuário sobre inexistência de Saldo Negociável para o cliente ( não impede de 
            //gravar ):
            //      Se ( TORPARM.IN_VERI_SALD_NGCV = 'S' ) e TORMOVD.CD_NATOPE = 'V'
            //         boolean pOr_Veri_Sald.fOr_Exis_Sald( :nCodCli, :sCodNeg, :sTipoMerc, :nQtde, out :sMensagem )
            //         Retorna TRUE se existir saldo negociável
            //         onde nCodCli   = <Codigo do Cliente - TORMOVD.CD_CLIENTE>
            //              sCodNeg   = <Codigo do Papel - TORMOVD.CD_NEGOCIO>
            //              sTipoMerc = <Codigo do Mercado - TORMOVD.CD_MERCAD>
            //              nQtde     = <Quantidade da Ordem - TORMOVD.QT_ORDEM - como é venda, passar negativo>
            //              sMensagem = Retorna mensagem a ser apresentada ao usuário
            //              }

            if ((new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarIndicadorVerificacaoSaldoNegociavel().Equals("S") //corrigido para usar novo nome do metodo - esertorio - 200804241648 - ref issue ID0003580
                && ordemAtual.NaturezaOperacao.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda))
            {
                BusinessEntity.Ordem beOrdem = new Ordens.BusinessEntity.Ordem();

                //dbOrdem.AddInParameter(dbCommand, "P_NCODCLI", DbType.Int32, ordem.CodigoCliente);
                beOrdem.CodigoCliente = ordemAtual.Cliente.Codigo.Value;

                //dbOrdem.AddInParameter(dbCommand, "P_SCODNEG", DbType.AnsiString, ordem.CodigoNegocio);
                beOrdem.Titulo = ordemAtual.Titulo;

                //dbOrdem.AddInParameter(dbCommand, "P_STIPOMERC", DbType.AnsiString, ordem.Mercado);
                beOrdem.TipoMercado = ordemAtual.TipoMercado;

                //dbOrdem.AddInParameter(dbCommand, "P_NQTDEMVTO", DbType.Decimal, ordem.Quantidade);
                beOrdem.Quantidade = ordemAtual.Quantidade;

                Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao mensagemValidacaoSaldo = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao();

                mensagemValidacaoSaldo.Codigo = 0;
                mensagemValidacaoSaldo.Descricao = (new ResourceAccess.Ordem()).VerficarSaldoNegociavel(beOrdem);

                ordemAlterada.MensagemValidacaoSaldo = mensagemValidacaoSaldo;
            }
            else
            {
                ordemAlterada.MensagemValidacaoSaldo = null;
            }
        }

        private void CasarOrdemAlterada()
        {
            //23.
            //-- Após gravação
            //Casar as ordens alteradas disparando o pacote:
            ////PR_CAAUTM.CASAMENTO_ESP('X')
            //PR_CAAUTM.CASAMENTO_ESP(:P_DATMOV), onde :P_DATMOV = 'X'

            (new ResourceAccess.OrdemMegaBolsa()).CasarOrdemAlterada();

        }

        /// <summary>
        /// Metodo responsavel por refazer o resumo financeiro dos cliente afetados pela alteracao da ordem
        /// Data: 10/12/2007
        /// Autor: Eduardo Sertorio
        /// Obs: Criacao do metodo
        /// 
        /// Data : 30/01/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Executar calculo financeiro apenas para cliente novo (ordem alterada).
        /// </summary>
        /// <param name="ordemAlterada"></param>
        /// <param name="ordemAtual"></param>
        /// <param name="dataPregao"></param>
        /// <returns></returns>
        private void DispararCalculoFinanceiroPacote(BusinessEntity.OrdemMegaBolsa ordemAlterada, BusinessEntity.OrdemMegaBolsa ordemAtual, DateTime? dataPregao)
        {
            //24.
            //Para cada cliente, novo e anterior, disparar cálculo financeiro pelo pacote:
            //PR_CALFME.FIN_MEG_CLI ( <Codigo do Cliente>, <Data do Pregão - dd/mm/yyyy>, 'N' )
            //onde <Data do Pregão - dd/mm/yyyy> = data do pregao do filtro da consulta. (nemir - 20071213 - por telefone)
            //caso nao escolha data do pregao, usar TORDATMOV.DT_DATMOV. (nemir - 20071213 - por telefone)

            if (!dataPregao.HasValue)
            {
                //caso nao escolha data do pregao, usar TORDATMOV.DT_DATMOV. (nemir - 20071213 - por telefone)
                dataPregao = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();
            }
            
            ResourceAccess.OrdemMegaBolsa raOrdemMegaBolsa = new ResourceAccess.OrdemMegaBolsa();

            raOrdemMegaBolsa.DispararCalculoFinanceiroPacote(ordemAlterada.Cliente.Codigo.Value, dataPregao.Value, "N");

            //nao executar para cliente anterior - eduardo - 20080130
            //raOrdemMegaBolsa.DispararCalculoFinanceiroPacote(ordemAtual.Cliente.Codigo.Value, dataPregao.Value, "N");
        }

        /// <summary>
        /// Operacao responsavel por validar o codigo de carteira da ordem mega bolsa
        /// Historico:
        /// Data:	02/01/2008
        /// Autor:	Eduardo Sertorio
        ///	Observacoes:  Criação da operacao
        /// </summary>
        public BusinessEntity.OrdemMegaBolsa ValidarCarteiraOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa ordemAlterada)
        {
            ordemAlterada.IsValidacaoOk = false;

            if (!ordemAlterada.Carteira.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_CARTEIRANULO); //"Carteira deve ser informada."
                throw validationException;
            }

            //Obter ordem atual para validacoes
            BusinessEntity.OrdemMegaBolsa ordemAtual = null;

            //Validar ordem alterada
            ValidarAlterarOrdemMegaBolsa(ordemAlterada, ref ordemAtual, ValidacaoParcial.Carteira);

            //20080425 12:25 - RValadao
            //A verificação é feita dentro do método ValidarAlterarOrdemMegaBolsa
            //ordemAlterada.IsValidacaoOk = true;

            return ordemAlterada;
        }

        /// <summary>
        /// Operacao responsavel por validar o tipo de liquidacao da ordem mega bolsa
        /// Historico:
        /// Data : 02/01/2008
        /// Autor: Eduardo Sertorio
        ///	Obs. :  Criação da operacao
        /// 
        /// Data : 01/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Revisao da operacao
        /// </summary>
        public BusinessEntity.OrdemMegaBolsa ValidarTipoLiquidacaoOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa ordemAlterada)
        {
            ordemAlterada.IsValidacaoOk = false;

            if (ordemAlterada.TipoLiquidacao == null)
                validationException.AddError(ERRO_ORDEMMEGABOLSA_TIPOLIQUIDACAONULO); //"Carteira deve ser informada."

            if (String.IsNullOrEmpty(ordemAlterada.Cliente.Apelido)) //incluido - eduardo - 20080201
                validationException.AddError(ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO);

            if (!ordemAlterada.DataOrdem.HasValue) //incluido - eduardo - 20080201
                validationException.AddError(ERRO_ORDEMMEGABOLSA_DATAORDEMNULO);

            if (!ordemAlterada.NumeroOrdem.HasValue) //incluido - eduardo - 20080201
                validationException.AddError(ERRO_ORDEMMEGABOLSA_NUMEROORDEMNULO);

            if (!ordemAlterada.NumeroOrdemSubSequencia.HasValue) //incluido - eduardo - 20080201
                validationException.AddError(ERRO_ORDEMMEGABOLSA_NUMEROSUBSEQORDEMNULO);

            if (validationException.ValidationErrors != null && validationException.ValidationErrors.Count > 0) //alterado - eduardo - 20080201
                throw validationException;

            //obter cliente da ordem alterada
            Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente beCliente =
                (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPorApelido(ordemAlterada.Cliente.Apelido);

            if (beCliente == null) //incluido - eduardo - 20080201
                validationException.AddError(ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO);

            ordemAlterada.Cliente = beCliente; //alterado - eduardo - 20080201

            //Obter ordem atual para validacoes
            BusinessEntity.OrdemMegaBolsa ordemAtual = ObterOrdemAtual(ordemAlterada);

            if (ordemAtual == null)
                throw new BusinessException(ERRO_ORDEMMEGABOLSA_ORDEMINVALIDAPARAALTERACAO);

            //select IN_CAR888 from torparm;
            string TORPARM__IN_CAR888 = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarIndicadorTipoLiquidacaoCustodianteAutomatico(); //renomeado - rvaladao - 20080504 23:30 - bug 3642

            //if in_car888 then 
            //    bCar888 := TRUE;
            //else
            //    bCar888 := FALSE;
            //end if;

            //If bCar888
            if (!String.IsNullOrEmpty(TORPARM__IN_CAR888) && TORPARM__IN_CAR888.Equals("S"))
            {
                //If (nClieInst != 0) and (nClieInst >  0)
                if (ordemAlterada.Cliente.CodigoClienteInstitucional.HasValue
                    && !ordemAlterada.Cliente.CodigoClienteInstitucional.Value.Equals(0))
                {
                    //If tblTorordmega.colMercado = 'VIS'
                    if (ordemAtual.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)
                        //OR tblTorordmega.colMercado = 'FRA'
                        || ordemAtual.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario)
                        //OR tblTorordmega.colMercado = 'EOC'
                        || ordemAtual.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra)
                        //OR tblTorordmega.colMercado = 'EOV'
                        || ordemAtual.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda)
                        //OR tblTorordmega.colMercado = 'LEI'
                        || ordemAtual.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Leilao)
                    )
                    {
                        //Call oTorordmega.fChangeStrAttribute('Inliquida', 'C')
                        ordemAlterada.TipoLiquidacao = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Custodiante;
                    }
                    //Else [If tblTorordmega.colMercado = 'VIS' OR ...]
                    else
                    {
                        //Call oTorordmega.fChangeStrAttribute('Inliquida', '')
                        ordemAlterada.TipoLiquidacao = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal;
                    }

                }
                //  Else [If (nClieInst != 0) and (nClieInst >  0)]
                else
                {
                    //Call oTorordmega.fChangeStrAttribute('Inliquida', '')
                    ordemAlterada.TipoLiquidacao = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal;
                }
                //Call oTorordmega.fChangeNumberAttribute('Cdcarliq', 0)
                ordemAlterada.Carteira = 0;
            }
            //Else (If bCar888)
            else
            {
                //Call oTorordmega.fChangeStrAttribute('Inliquida', '')
                ordemAlterada.TipoLiquidacao = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal;
            }

            return ordemAlterada;
        }

        /// <summary>
        /// Operacao responsavel por validar o percentual de reducao/acrescimo da ordem mega bolsa
        /// Historico:
        /// Data:	02/01/2008
        /// Autor:	Eduardo Sertorio
        ///	Observacoes:  Criação da operacao
        /// </summary>
        public void ValidarPercentualReducaoAcrescimoOrdemMegaBolsa(BusinessEntity.OrdemMegaBolsa ordemAlterada)
        {
            ordemAlterada.IsValidacaoOk = false;

            if (!ordemAlterada.PercentualReducaoAcrescimo.HasValue)
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_PERCENTUALREDACRNULO); //"Percentual deve ser informada."
                //throw validationException;
            }

            if (String.IsNullOrEmpty(ordemAlterada.Cliente.Apelido))
            {
                validationException.AddError(ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO);
                //throw validationException;
            }
            else 
            {
                Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente beCliente = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPorApelido(ordemAlterada.Cliente.Apelido);
                if (beCliente == null)
                {
                    validationException.AddError(ERRO_ORDEMMEGABOLSA_APELIDOCLIENTEINVALIDO);
                }
                ordemAlterada.Cliente = beCliente;
            }

            if (validationException.ValidationErrors != null && validationException.ValidationErrors.Count > 0)
                throw validationException;

            //Obter ordem atual para validacoes
            BusinessEntity.OrdemMegaBolsa ordemAtual = null;

            //Validar ordem alterada
            //ValidarAlterarOrdemMegaBolsa(ordemAlterada, ref ordemAtual, ValidacaoParcial.PercentualReducaoAcrescimo); //comentado - eduardo - 20080201
            ValidarPercentualCorretagem(ordemAlterada, ordemAtual); //20080513 00:09 - RValadao - Descomentado.

            ordemAlterada.IsValidacaoOk = true;
        }

        /// Data:12/05/2008 14:30
        /// Autor:Rvaladao
        /// Obs: Validar o estado do sistema
        /// Issue 4618
        private void ValidarEstadoSistema()
        {
            if ((new Bovespa.Ordens.ResourceAccess.MovimentoControleOrdens()).ConsultarTipoMovimento() != "A")
            {
                throw new BusinessException(ERRO_NEGOCIO_CONTROLE_ORDENS_FECHADO);
            }
        }

        #endregion
    }
}
